
//! 区块链核心模块，负责链的创建、区块添加和验证等核心逻辑
use sha2::{Sha256, Digest};
//use crate::transaction::TransactionType;
use std::collections::HashMap;
use crate::block::Block;
use crate::pow::ProofOfWork;
use crate::transaction::Transaction;
use crate::transaction_bbs::BbsTransaction;
use crate::smart_contract::SmartContract;
use chrono::Utc;
//use serde::Deserialize;
use serde::{Serialize, Deserialize};

/// 区块链数据结构
//#[derive(Debug, Clone)]
#[derive(Debug, Clone, Serialize, Deserialize)]	  // 确保包含Clone
#[allow(dead_code)] // TODO: 待实现的智能合约功能
pub struct Blockchain {
    /// 区块的链式存储（内存中完整链）
    chain: Vec<Block>,
    /// 工作量证明算法实例
//    pow: ProofOfWork,
    pow: Option<ProofOfWork>,  // 临时设为可选以兼容旧数据
    /// 区块哈希快速查询表（模拟UTXO模型）
    block_map: HashMap<String, Block>,
    /// 智能合约执行器（预留功能）
//    smart_contract: SmartContract,
    smart_contract: Option<SmartContract>,  // 临时设为可选
    /// 交易池（等待打包的交易）
    // 如果改为公有可直访问（快速解决方案）：
    pub pending_transactions: Vec<Transaction>,  // 添加pub
}

impl Blockchain {
    /// 初始化新区块链
    /// # 参数
    /// - difficulty: 工作量证明难度（前导零数量）
    pub fn new(difficulty: usize) -> Self {
        // 初始化工作量证明算法
        //let pow = ProofOfWork::new(difficulty);
        let pow = Some(ProofOfWork::new(difficulty));
        // 生成创世区块
        let genesis_block = Block::genesis();
        // 对创世区块进行挖矿计算
        //let mined_block = pow.mine_block(genesis_block);

        // 安全解包Option
        let mined_block = pow.as_ref()
            .expect("PoW should be initialized")
            .mine_block(genesis_block);

        // 构建初始区块映射
        let mut block_map = HashMap::new();
        block_map.insert(mined_block.hash.clone(), mined_block.clone());

        Blockchain {
            chain: vec![mined_block],
            pow,
            block_map,
            //smart_contract: SmartContract, // 预留智能合约实例
	    smart_contract: Some(SmartContract::default()),
            pending_transactions: Vec::new(),
        }
    }

    /// 添加新区块到链上
    /// # 参数
    /// - miner_address: 矿工奖励接收地址
    pub fn add_block(&mut self, miner_address: &str) {
        // 获取上一个区块作为父区块
        let previous_block = self.chain.last().expect("Chain should have genesis block");
        
/*        // 取出待处理交易并进行签名验证
        let mut transactions = std::mem::take(&mut self.pending_transactions)
            .into_iter()
            .filter(|tx| tx.verify())	 // BBS交易验证失败导致被过滤
            .collect::<Vec<_>>();
*/
        // 正确取出待处理交易（保留所有权）
        let mut pending_txs = Vec::new();
        std::mem::swap(&mut self.pending_transactions, &mut pending_txs);
    
        // 筛选有效交易
        let mut transactions = pending_txs.into_iter()
            .filter(|tx| tx.verify())
            .collect::<Vec<_>>();

        // 添加矿工奖励交易（固定50个代币）
        transactions.push(Transaction::new(
            "0".to_string(),          // 系统账户
            miner_address.to_string(),// 矿工地址
            50                        // 奖励金额
	// ).apply_type(TransactionType::Normal)); // 确保类型正确
        ));

        // 构建新区块
        let new_block = Block::new(
            previous_block.index + 1, // 区块高度递增
            Utc::now().timestamp(),   // 当前时间戳
            transactions,             // 包含的交易
            previous_block.hash.clone(), // 父区块哈希
            0,                        // 初始nonce值
        );

        // 执行工作量证明计算
        //let mined_block = self.pow.mine_block(new_block);
        let mined_block = if let Some(pow) = &self.pow {
            pow.mine_block(new_block)
        } else {
            return; // 或处理错误
        };
        // 更新区块映射
        self.block_map.insert(mined_block.hash.clone(), mined_block.clone());
        // 将新区块加入链
        self.chain.push(mined_block);
    }

    /// 验证区块链完整性
    /// 返回 bool 表示是否有效
    pub fn is_valid(&self) -> bool {
        // 空链无效
        if self.chain.is_empty() {
            return false;
        }

        // 验证创世区块规则
        let genesis = &self.chain[0];
        if genesis.index != 0 ||          // 高度必须为0
           genesis.previous_hash != "0" || // 前哈希必须为"0"
           !genesis.transactions.is_empty() // 必须无交易
        {
            return false;
        }

        // 遍历验证每个区块
        for i in 1..self.chain.len() {
            let current = &self.chain[i];
            let prev = &self.chain[i - 1];
            
            // 验证当前区块哈希计算正确
            // 验证父哈希链接正确
            // 验证工作量证明有效性
            if current.hash != current.calculate_hash() ||
               current.previous_hash != prev.hash ||
               // !self.pow.is_valid(current)
               !self.pow.as_ref().map(|p| p.is_valid(current)).unwrap_or(false)
            {
                return false;
            }
        }
        true
    }

    // 其他方法...

    pub fn chain(&self) -> &[Block] {
        &self.chain
    }

    // ▼▼▼ 移除未使用的链访问器 ▼▼▼
    //pub fn chain_mut(&mut self) -> &mut Vec<Block> {
    //    &mut self.chain
    //}

    pub fn add_transaction(&mut self, tx: Transaction) {
        self.pending_transactions.push(tx);
    }

    #[allow(dead_code)]  // 添加到方法前
    pub fn pending_transactions(&self) -> &[Transaction] {
        &self.pending_transactions
    }

    pub fn add_bbs_transaction(&mut self, tx: BbsTransaction) -> anyhow::Result<()> {
        // 验证交易逻辑
        self.pending_transactions.push(tx.into());
        Ok(())
    }

    #[allow(dead_code)]  // 计划在内容验证功能中使用
    pub fn get_tx_hash(&self, tx_hash: &str) -> Option<String> {
/*        self.chain.iter()
            .flat_map(|block| &block.transactions)
            // .find(|tx| tx.hash == tx_hash)
            // .map(|tx| tx.hash.clone())
            .find(|tx| match tx {
                Transaction::Legacy { hash, .. } => hash == tx_hash,
                Transaction::BbsPost { hash, .. } => hash == tx_hash,
                // 处理其他类型
		Transaction::BbsComment { hash, .. } => hash == tx_hash,
            })
            .map(|tx| tx.calculate_hash())
*/
        self.chain.iter()
            .flat_map(|block| &block.transactions)
            .find_map(|tx| match tx {
                Transaction::Legacy { hash, .. } if hash == tx_hash => Some(hash.clone()),
                Transaction::BbsPost { hash, .. } if hash == tx_hash => Some(hash.clone()),
                Transaction::BbsComment { hash, .. } if hash == tx_hash => Some(hash.clone()),
                _ => None
            })
    }

/*    pub fn load() -> anyhow::Result<Self> {

        // 添加旧数据转换结构
        #[derive(serde::Deserialize)]
        struct LegacyTransaction {
            sender: String,
            receiver: String,
            amount: u64,
            signature: Vec<u8>,
        }

        #[derive(serde::Deserialize)]
        struct LegacyBlock {
            index: u64, // 保持原始类型 32, // 注意这里使用 u32
            timestamp: i64,
            transactions: Vec<LegacyTransaction>,
            previous_hash: String,
            hash: String,
            nonce: u64,
            merkle_root: String,
        }
        
//        let data = std::fs::read_to_string("blockchain.json")?;
//        let blockchain = serde_json::from_str(&data)?;
        let mut chain = load_from_file()?;
        
        for block in &mut chain {
            for tx in &mut block.transactions {
                // 为旧交易添加类型标识
                if !tx.contains_key("tx_type") {
                    tx.tx_type = TransactionType::Legacy;
                }
            }
        }

//        let mut blockchain: Blockchain = serde_json::from_str(&std::fs::read_to_string("blockchain.json")?);
        let data = std::fs::read_to_string("blockchain.json")?;

        
        // 添加旧数据转换层
//        let chain: Vec<Block> = match serde_json::from_str(&data) {
	let _chain: Vec<Block> = match serde_json::from_str(&data) { // ✅ 添加下划线

	    // 新数据格式直接解析
            Ok(v) => v,

	    // ▲▲▲ 重构旧数据转换逻辑
            Err(_) => {
               
                // 转换旧区块结构
                let legacy: Vec<LegacyBlock> = serde_json::from_str(&data)?;
		// 修改转换逻辑
		legacy.into_iter().map(|b| Block {
		    index: b.index, // 不再需要类型转换
                    timestamp: b.timestamp,
                    transactions: b.transactions.into_iter().map(|tx| {
                        Transaction::Legacy {
                            sender: tx.sender,
                            receiver: tx.receiver,
                            amount: tx.amount,
                            signature: tx.signature,
                            hash: String::new(), // 后续计算
                        }
                    }).collect(),
                    previous_hash: b.previous_hash,
                    hash: b.hash,
                    nonce: b.nonce,
                    merkle_root: b.merkle_root,
                }).collect()

                // 解析旧格式数据
                let legacy_chain: Vec<LegacyBlock> = serde_json::from_str(&data)?;
                let mut chain = Vec::with_capacity(legacy_chain.len());

                // 转换每个区块
                for lb in legacy_chain {
                    let mut transactions = Vec::new();
                
                    // 转换每个交易并生成哈希
                    for lt in lb.transactions {
                        // ▲▲▲ 动态生成交易哈希
                        let mut hasher = Sha256::new();
                        hasher.update(format!("{}{}{}", lt.sender, lt.receiver, lt.amount));
                        let hash = format!("{:x}", hasher.finalize());

                        transactions.push(Transaction::Legacy {
                            sender: lt.sender,
                            receiver: lt.receiver,
                            amount: lt.amount,
                            signature: lt.signature,
                            hash, // ▲▲▲ 填充计算的哈希值
                        });
                    }
 
                    chain.push(Block {
                        index: lb.index,
                        timestamp: lb.timestamp,
                        transactions,
                        previous_hash: lb.previous_hash,
                        hash: lb.hash,
                        nonce: lb.nonce,
                        merkle_root: lb.merkle_root,
                    });
                }

                // ▲▲▲ 构建完整区块链实例
                Blockchain {
                    chain,
                    pow: Some(ProofOfWork::new(4)),  // 默认难度
                    block_map: HashMap::new(),       // 初始化空映射
                    smart_contract: Some(SmartContract::default()),
                    pending_transactions: Vec::new(),
                }
            }
        };
        
        // ...其余初始化逻辑不变...

        //let mut blockchain: Blockchain = serde_json::from_str(&data)?;
	// 兼容旧版本数据（保留原始逻辑）
	let mut blockchain = blockchain;
	// 修正3：移除冗余的重新绑定
        
        // 为旧交易添加类型标识
        for block in blockchain.chain.iter_mut() {
            for tx in block.transactions.iter_mut() {
                if tx.tx_type == TransactionType::Legacy {
                    // 生成兼容哈希
                    let mut hasher = Sha256::new();
                    hasher.update(format!("{}{}{}", tx.sender, tx.receiver, tx.amount));
                    tx.hash = hex::encode(hasher.finalize());
                }
            }
        }

        // 兼容旧版本数据
        if blockchain.pow.is_none() {
            blockchain.pow = Some(ProofOfWork::new(4));  // 默认难度
        }
        if blockchain.smart_contract.is_none() {
            blockchain.smart_contract = Some(SmartContract::default());
        }

        Ok(blockchain)
    }
*/
    //pub fn load() -> anyhow::Result<Self> {
    /// 统一加载方法（保持原有逻辑）
    pub fn load(filename: &str) -> anyhow::Result<Self> {
        // 添加旧数据转换结构
        #[derive(serde::Deserialize)]
        struct LegacyTransaction {
            sender: String,
            receiver: String,
            amount: u64,
            signature: Vec<u8>,
        }

        #[derive(serde::Deserialize)]
        struct LegacyBlock {
            index: u64, // 保持原始类型
            timestamp: i64,
            transactions: Vec<LegacyTransaction>,
            previous_hash: String,
            hash: String,
            nonce: u64,
            merkle_root: String,
        }

    	// ▼▼▼ 修改1：添加三级数据兼容解析 ▼▼▼
    	#[derive(serde::Deserialize)]
    	struct LegacyBlockchain {
    	    chain: Vec<Block>,
    	}

        let data = std::fs::read_to_string(filename)?;//"blockchain.json")?;
    
        // 主解析逻辑
        let blockchain = match serde_json::from_str(&data) {
            // 新格式直接解析成功
            Ok(bc) => bc,
        
            Err(_) => match serde_json::from_str(&data) {
                Ok(LegacyBlockchain { chain }) => Blockchain {
                    chain,
                    pow: Some(ProofOfWork::new(4)),
                    block_map: HashMap::new(),
                    smart_contract: None,
                    pending_transactions: Vec::new(),
                },

                // ▲▲▲ 旧数据转换分支
                Err(_) => {
                    // 解析旧格式数据
                    let legacy_chain: Vec<LegacyBlock> = serde_json::from_str(&data)?;
                    let mut chain = Vec::with_capacity(legacy_chain.len());

                    // 转换每个区块
                    for lb in legacy_chain {
                        let mut transactions = Vec::new();
                
                        // 转换每个交易
                        for lt in lb.transactions {
                            // ▲▲▲ 动态生成交易哈希
                            let mut hasher = Sha256::new();
                            hasher.update(format!("{}{}{}", lt.sender, lt.receiver, lt.amount));
                            let hash = format!("{:x}", hasher.finalize());

                            transactions.push(Transaction::Legacy {
                                sender: lt.sender,
                                receiver: lt.receiver,
                                amount: lt.amount,
                                signature: lt.signature,
                                hash, // 填充计算的哈希值
                            });
                        }

                        // 构建新区块
                        chain.push(Block {
                            index: lb.index,
                            timestamp: lb.timestamp,
                            transactions,
                            previous_hash: lb.previous_hash,
                            hash: lb.hash,
                            nonce: lb.nonce,
                            merkle_root: lb.merkle_root,
                        });
                    }

                    // ▲▲▲ 构建完整区块链实例
                    Blockchain {
                        chain,
                        pow: Some(ProofOfWork::new(4)),  // 默认难度
                        block_map: HashMap::new(),       // 初始化空映射
                        smart_contract: Some(SmartContract::default()),
                        pending_transactions: Vec::new(),
                    }
                }

	    }
        };

        // 兼容旧版本数据初始化（保留原始逻辑）
        let mut blockchain = blockchain;
        if blockchain.pow.is_none() {
            blockchain.pow = Some(ProofOfWork::new(4));
        }
        if blockchain.smart_contract.is_none() {
            blockchain.smart_contract = Some(SmartContract::default());
        }

        Ok(blockchain)
    }

    // 添加 save 方法
    //pub fn save(&self) -> anyhow::Result<()> {
    /// 统一保存方法（添加成功输出）
    pub fn save(&self, filename: &str) -> anyhow::Result<()> {
        // 错误：原代码只保存了chain字段 → let data = serde_json::to_string_pretty(&self.chain)?;
	// 修正：保存整个区块链结构体 ↓
	let data = serde_json::to_string_pretty(self)?; // ✅ 关键修改
        //std::fs::write("blockchain.json", data)?;
        // ▲▲▲ 添加换行符保持格式一致
        //std::fs::write("blockchain.json", format!("{}\n", data))?;
        std::fs::write(filename, data)?;
        println!("\n💾 区块链数据已保存到 {}", filename); // 新增成功输出
	//std::fs::write("blockchain.json", data)?; // 删除 format!("\n") 
	//println!("\n💾 区块链数据已保存到blockchain.json"); // 新增成功输出
        Ok(())
    }
}
